﻿#include <iostream>
#include <list>
#include <bitset>
template <typename _Tp>
class shared_ptr
{
public:
	//...
	template<typename _Tp1>
	explicit shared_ptr(_Tp1* __p) {}

	// ...

};

class Base1 {};
class Derived1 : public Base1 {};
class Base2 {};
class Derived2 : public Base2 {};

template <class T1, class T2>
struct pair {
	T1 frist;
	T2 second;
	pair() :frist(T1()), second(T2()) {}
	pair(const T1& a, const T2& b)
		:frist(a), second(b) {}

	//模板型的构造函数。
	template <class U1, class U2>
	pair(const pair<U1, U2>& p) :
		frist(p.frist), second(p.second) {}
};

namespace hdp1
{
	class MyAlloc {};

	template <class T, class Alloc = MyAlloc>
	class MyVector
	{
	public:
		typedef T value_type;
		typedef value_type * iterator;
		template <class I>
		void assign(I frist, I last)
		{
			std::cout << __FUNCTION__ << std::endl;
		}
	};
}

namespace hdp2 {
	class MyAlloc {};

	template <class T, class Alloc = MyAlloc>
	class MyVector {
	public:
		typedef T value_type;
		typedef value_type* iterator;

		template <class I>
		MyVector(I frist, I last)
		{
			std::cout << __FUNCTION__ << std::endl;
		}
	};
}

void print() {}

template <typename T, typename... Types>
void print(const T&fristArg, const Types&... args)
{
	std::cout << fristArg << std::endl;
	print(args...);
}

int main(void)
{
	Base1 * ptr = new Derived1;//一个父类 对象指针可以指向一个子类 的实例化对象。

	//常规操作，一个类模板中传入两个不同类型。
	pair<Derived1, Derived2> pD;
	pair<Base1, Base2> pB;

	Derived1 d1;
	Derived2 d2;

	//特殊操作来了，通过调用另外一种构造函数，我称之为 模板型的构造函数。
	pair<Base1, Base2> p2(pair<Derived1, Derived2>(d1, d2));
	//从表面上看，是传递了两个父类，但实际上初始化的确实两个子类。
	//  pair<Base1, Base2> 类型 
	//  p2 变量名
	//  (pair<Derived1, Derived2>(d1, d2)) 模板构造函数
		//  pair<Derived1, Derived2> 模板构造函数的参数
		//  (d1, d2) 是两个参数，对应的是 pair(const T1& a, const T2& b)

	shared_ptr<Base1> sptr(new Derived1);

	int a[] = { 1, 2, 3 };
	std::list<int> l(a, a + 3);
	{
		hdp1::MyVector<int> v;

		v.assign(a, a + 3);
		v.assign(l.begin(), l.end());
	}
	hdp2::MyVector<int> v(a, a + 3);
	hdp2::MyVector<int> v2(l.begin(), l.end());

	print(7.5, "Hello", std::bitset<16>(377), 42);


	auto who = { 1, 4, 5,6,7 };//who 对应的类型为 std::initializer_list<int> who;

	std::cout << sizeof(who) << std::endl;

	for (int i : { 1, 3, 5, 6, 7, 8, 9}) {
		std::cout << i << std::endl; 
	}

	//for (int& elem : who) { //who 中的数据不能被修改
	//	elem *= 3;
	//	std::cout << elem  << std::endl;
	//}
	
	return 0;
}
